package my;

import my.printer.BinaryTreeInfo;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

/**
 * <p>
 * 二叉搜索树
 * </p>
 *
 * @author AJun
 * @since 2020/8/14
 */
@SuppressWarnings({"unchecked", "unused", "SameParameterValue"})
public class BinarySearchTree<E> implements BinaryTreeInfo {

    /**
     * 二叉树容量
     */
    private int size;

    /**
     * 根节点
     */
    private Node<E> root;

    /**
     * 元素比较器
     */
    private final Comparator<E> comparator;

    public BinarySearchTree() {
        this(null);
    }

    public BinarySearchTree(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
        root = null;
        size = 0;
    }

    public void add(E element) {
        elementNotNullCheck(element);

        // 添加的第一个节点，根节点，根节点没有父节点
        if (root == null) {
            root = new Node<>(element, null);
            size++;
            return;
        }

        // 添加的不是第一个节点
        // 找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        while (node != null) {
            cmp = compare(element, node.element);
            parent = node;
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else {
                // 相等，覆盖其值，防止自定义对象的其它属性值不一样
                node.element = element;
                return;
            }
        }

        // 看看插入到父节点的哪个位置
        Node<E> newNode = new Node<>(element, parent);
        if (cmp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;
    }

    public void remove(E element) {
        remove(node(element));
    }

    public void remove(Node<E> node) {
        if (node == null) return;

        size--;

        // 度为 2 的节点
        if (node.hasTwoChildren()) {
            Node<E> s = successor(node); // 后继(这里前驱和后继都可以)
            // 用后继节点的值覆盖度为 2 的节点的值
            node.element = s.element;
            // 删除后继节点
            node = s;
        }

        // 删除 node 节点(node 的度必然是 1 或 0)
        Node<E> replacement = (node.left != null) ? node.left : node.right;
        if (replacement != null) {
            // node 是度为 1 的节点
            // 更改 parent
            replacement.parent = node.parent;
            // 更改 parent 的 left 和 right 的指向
            if (node.parent == null) {
                // node 是度为 1 的节点并且是根节点
                root = replacement;
            } else {
                if (node == node.parent.left)
                    node.parent.left = replacement;
                else // node == node.parent.right
                    node.parent.right = replacement;
            }
        } else if (node.parent == null) {
            // node 是叶子节点 且 node 是根节点
            root = null;
        } else {
            // node 是叶子节点，但不是根节点
            if (node == node.parent.left) {
                // 如果是左子节点，则删除父节点左边
                node.parent.left = null;
            } else { // node == node.parent.right
                // 如果是左子节点，则删除父节点右边
                node.parent.right = null;
            }
        }
    }

    /**
     * 根据传入的元素找到该节点
     */
    private Node<E> node(E element) {
        Node<E> node = root;
        while (node != null) {
            int cmp = compare(element, node.element);
            if (cmp == 0) {
                return node;
            } else if (cmp > 0) {
                node = node.right;
            } else { // cmp < 0
                node = node.left;
            }
        }
        return null;
    }

    public boolean contains(E element) {
        return node(element) != null;
    }

    /**
     * 遍历结果
     */
    private final List<E> result = new ArrayList<>();

    private void cleanResult() {
        result.clear();
    }

    /**
     * 前序遍历: 中左右
     */
    public List<E> preorderTraversal() {
        return preorderTraversal(true);
    }

    public List<E> preorderTraversal(boolean recursion) {
        cleanResult();
        return recursion ? preorderTraversal(root) : preorderTraversal(root, 0);
    }

    /**
     * 从指定的根节点开始递归前序遍历
     *
     * @param node 根节点
     */
    private List<E> preorderTraversal(Node<E> node) {
        if (node == null) return result;

        result.add(node.element);
        preorderTraversal(node.left);
        preorderTraversal(node.right);
        return result;
    }

    /**
     * 前序遍历，非递归
     *
     * @param node        根节点
     * @param placeholder 无用的占位符
     */
    private List<E> preorderTraversal(Node<E> node, int placeholder) {
        if (node == null) return result;

        Stack<Node<E>> stack = new Stack<>();
        stack.push(node);
        while (!stack.isEmpty()) {
            Node<E> top = stack.pop();
            result.add(top.element);

            if (top.right != null)
                stack.push(top.right);
            if (top.left != null)
                stack.push(top.left);
        }
        return result;
    }

    private List<E> preorderTraversal2(Node<E> node, int placeholder) {
        if (node == null) return result;

        Stack<Node<E>> stack = new Stack<>();
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                result.add(node.element);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        return result;
    }

    /**
     * 中序遍历: 左中右
     */
    public List<E> inorderTraversal() {
        return inorderTraversal(true);
    }

    public List<E> inorderTraversal(boolean recursion) {
        cleanResult();
        return recursion ? inorderTraversal(root) : inorderTraversal(root, 0);
    }

    /**
     * 从指定的根节点开始递归中序遍历
     *
     * @param node 根节点
     */
    private List<E> inorderTraversal(Node<E> node) {
        if (node == null) return result;

        inorderTraversal(node.left);
        result.add(node.element);
        inorderTraversal(node.right);
        return result;
    }

    /**
     * 中序遍历，非递归
     *
     * @param node        根节点
     * @param placeholder 无用的占位符
     */
    private List<E> inorderTraversal(Node<E> node, int placeholder) {
        if (node == null) return result;

        Stack<Node<E>> stack = new Stack<>();
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            result.add(node.element);
            node = node.right;
        }
        return result;
    }

    /**
     * 后序遍历: 左右中
     */
    public List<E> postorderTraversal() {
        return postorderTraversal(true);
    }

    public List<E> postorderTraversal(boolean recursion) {
        cleanResult();
        return recursion ? postorderTraversal(root) : postorderTraversal(root, 0);
    }

    /**
     * 从指定的根节点开始递归后序遍历
     *
     * @param node 根节点
     */
    private List<E> postorderTraversal(Node<E> node) {
        if (node == null) return result;

        postorderTraversal(node.left);
        postorderTraversal(node.right);
        result.add(node.element);
        return result;
    }

    /**
     * 后序遍历，非递归
     *
     * @param node        根节点
     * @param placeholder 无用的占位符
     */
    private List<E> postorderTraversal(Node<E> node, int placeholder) {
        if (node == null) return result;

        Stack<Node<E>> stack = new Stack<>();
        Node<E> last = null;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            if (!stack.isEmpty()) {
                Node<E> top = stack.pop();
                if (top.right == null || last == top.right) {
                    // 栈顶是叶子节点
                    result.add(top.element);
                    last = top;
                } else {
                    stack.push(top);
                    node = top.right;
                }
            }
        }
        return result;
    }

    /**
     * 层序遍历: 从上到下，从左到右依次访问
     */
    public List<E> levelOrderTraversal() {
        cleanResult();

        if (root == null) return result;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<E> head = queue.remove();// 队头出队
            result.add(head.element);

            if (head.left != null)
                queue.add(head.left);
            if (head.right != null)
                queue.add(head.right);
        }
        return result;
    }

    /**
     * 前序遍历
     */
    public void preorder(Visitor<E> visitor) {
        preorder(root, visitor);
    }

    private void preorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor == null) return;

        visitor.visit(node.element);
        preorder(node.left, visitor);
        preorder(node.right, visitor);
    }

    /**
     * 中序遍历
     */
    public void inorder(Visitor<E> visitor) {
        inorder(root, visitor);
    }

    private void inorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor == null) return;

        inorder(node.left, visitor);
        visitor.visit(node.element);
        inorder(node.right, visitor);
    }

    /**
     * 后序遍历
     */
    public void postorder(Visitor<E> visitor) {
        postorder(root, visitor);
    }

    private void postorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor == null) return;

        postorder(node.left, visitor);
        postorder(node.right, visitor);
        visitor.visit(node.element);
    }

    /**
     * 层级遍历
     */
    public void levelOrder(Visitor<E> visitor) {
        if (root == null || visitor == null) return;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<E> head = queue.remove();// 队头出队
            visitor.visit(head.element); // 监听器

            if (head.left != null)
                queue.add(head.left);
            if (head.right != null)
                queue.add(head.right);
        }
    }

    /**
     * 提供给外界自定义遍历逻辑
     */
    public interface Visitor<E> {
        void visit(E element);
    }

    /**
     * 返回二叉树高度: 迭代-层序遍历
     */
    public int heightLevelOrder() {
        if (root == null) return 0;

        int height = 0; // 树的高度
        int levelSize = 1; // 每一层的元素数量，默认加入了根节点，所以默认为 1
        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<E> head = queue.remove();
            // 每次访问一个元素，将这一层的元素数量-1，如果元素数量变为0，则说明这一层已经访问完毕
            levelSize--;

            if (head.left != null)
                queue.add(head.left);
            if (head.right != null)
                queue.add(head.right);

            if (levelSize == 0) { // 意味着即将要访问下一层
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }

    /**
     * 返回二叉树高度: 递归
     */
    public int height() {
        return height(root);
    }

    private int height(Node<E> node) {
        if (node == null) return 0;
        return 1 + Math.max(height(node.left), height(node.right));
    }

    /**
     * 判断是否是一棵完全二叉树
     */
    public boolean isComplete() {
        if (root == null) return false;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);

        boolean leaf = false; // 标记: 是否为叶子节点
        while (!queue.isEmpty()) {
            Node<E> node = queue.remove();

            // 如果要求当前节点必须为叶子节点，但此节点并不是叶子节点，不是完全二叉树
            if (leaf && !node.isLeaf()) return false;

            if (node.left != null) {
                queue.add(node.left);
            } else if (node.right != null) {
                // 左为空而右不为空，不是完全二叉树
                // node.left == null && node.right != null
                return false;
            }

            if (node.right != null) {
                queue.add(node.right);
            } else {
                // node.right == null
                // 右为空，说明之后遍历的节点都必须是叶子节点
                leaf = true; // 标记为叶子节点
            }
        }
        return true; // 队列为空，说明是完全二叉树
    }

    /**
     * 翻转二叉树
     */
    public void reverse() {
        reverse(root);
    }

    private void reverse(Node<E> node) {
        if (node == null) return;

        Node<E> tmp = node.left;
        node.left = node.right;
        node.right = tmp;

        reverse(node.right);
        reverse(node.left);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        toString(root, sb, "");
        return sb.toString();
    }

    private void toString(Node<E> node, StringBuilder sb, String prefix) {
        if (node == null) return;

        sb.append(prefix).append(node.element).append("\n");
        toString(node.left, sb, prefix + "L---");
        toString(node.right, sb, prefix + "R---");
    }

    /**
     * 返回 0  e1 = e2
     * 返回 1  e1 > e2
     * 返回 -1 e1 < e2
     */
    private int compare(E e1, E e2) {
        if (comparator != null)
            return comparator.compare(e1, e2);

        // 判断传入的类是否实现了 Comparable
        if (e1 instanceof Comparable) {
            return ((Comparable<E>) e1).compareTo(e2);
        }

        // 没有传入比较器，抛出类型转换异常
        throw new ClassCastException("Element must implement Comparable interface");
    }

    /**
     * 空值检测，元素不得为 null
     */
    private void elementNotNullCheck(E element) {
        if (element == null)
            throw new IllegalArgumentException("Element must not be null");
    }

    /**
     * 返回传入节点的前驱节点
     */
    private Node<E> predecessor(Node<E> node) {
        if (node == null) return null;

        // 前驱节点在左子树中(left.right.right...)
        Node<E> p = node.left;
        if (p != null) {
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }

        // 从父节点或祖父节点中寻找前驱节点
        // 如果父节点不为空 且 父节点的左子树是此节点，则一直往上找父节点
        while (node.parent != null && (node == node.parent.left)) {
            node = node.parent;
        }
        // 没找到父节点 node.parent == null
        // 父节点的右子节点是此节点 node = node.parent.right
        return node.parent;
    }

    /**
     * 返回传入节点的前驱节点
     */
    private Node<E> successor(Node<E> node) {
        if (node == null) return null;

        // 前驱节点在右子树中(right.left.left....)
        Node<E> p = node.right;
        if (p != null) {
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }

        // 从父节点或祖父节点中寻找前驱节点
        // 如果父节点不为空 且 父节点的右子树是此节点，则一直往上找父节点
        while (node.parent != null && (node == node.parent.right)) {
            node = node.parent;
        }
        return node.parent;
    }

    /**
     * 二叉搜索树的节点
     */
    private static class Node<E> {
        E element; // 节点元素
        Node<E> parent; // 父节点
        Node<E> left; // 左子节点
        Node<E> right; // 右子节点

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        /**
         * 判断节点是否是叶子节点
         */
        public boolean isLeaf() {
            return left == null && right == null;
        }

        /**
         * 判断节点左右都不为空，有俩个子节点
         */
        public boolean hasTwoChildren() {
            return left != null && right != null;
        }
    }

    /* 二叉搜索树打印器 */
    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>) node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>) node).right;
    }

    @Override
    public Object string(Object node) {
        Node<E> n = (Node<E>) node;
        String parentStr = "null";
        if (n.parent != null) parentStr = n.parent.element.toString();
        return n.element + "(parent => " + parentStr + ")";
    }

}
